home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / MacHacksBug / Python 1.5.2c1 / Demo / tkinter / www / fmt.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-06-23  |  27.6 KB  |  662 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 1.5)
  3.  
  4. import string
  5. import Para
  6.  
  7. class NullBackEnd:
  8.     
  9.     def __init__(self):
  10.         pass
  11.  
  12.     
  13.     def addpara(self, p):
  14.         pass
  15.  
  16.     
  17.     def bgn_anchor(self, id):
  18.         pass
  19.  
  20.     
  21.     def end_anchor(self, id):
  22.         pass
  23.  
  24.  
  25.  
  26. class SavingBackEnd(NullBackEnd):
  27.     
  28.     def __init__(self):
  29.         self.paralist = []
  30.  
  31.     
  32.     def addpara(self, p):
  33.         self.paralist.append(p)
  34.  
  35.     
  36.     def hitcheck(self, h, v):
  37.         hits = []
  38.         for p in self.paralist:
  39.             if v <= v:
  40.                 pass
  41.             elif v <= p.bottom:
  42.                 for id in p.hitcheck(h, v):
  43.                     pass
  44.                 
  45.             
  46.         
  47.         return hits
  48.  
  49.     
  50.     def extract(self):
  51.         text = ''
  52.         for p in self.paralist:
  53.             text = text + p.extract()
  54.         
  55.         return text
  56.  
  57.     
  58.     def extractpart(self, long1, long2):
  59.         if long1 > long2:
  60.             (long1, long2) = (long2, long1)
  61.         
  62.         (para1, pos1) = long1
  63.         (para2, pos2) = long2
  64.         text = ''
  65.         while para1 < para2:
  66.             ptext = self.paralist[para1].extract()
  67.             text = text + ptext[pos1:]
  68.             pos1 = 0
  69.             para1 = para1 + 1
  70.         ptext = self.paralist[para2].extract()
  71.         return text + ptext[pos1:pos2]
  72.  
  73.     
  74.     def whereis(self, d, h, v):
  75.         total = 0
  76.         for i in range(len(self.paralist)):
  77.             p = self.paralist[i]
  78.             result = p.whereis(d, h, v)
  79.         
  80.         return None
  81.  
  82.     
  83.     def roundtowords(self, long1, long2):
  84.         (i, offset) = long1
  85.         text = self.paralist[i].extract()
  86.         while offset > 0 and text[offset - 1] != ' ':
  87.             offset = offset - 1
  88.         long1 = (i, offset)
  89.         (i, offset) = long2
  90.         text = self.paralist[i].extract()
  91.         n = len(text)
  92.         while offset < n - 1 and text[offset] != ' ':
  93.             offset = offset + 1
  94.         long2 = (i, offset)
  95.         return (long1, long2)
  96.  
  97.     
  98.     def roundtoparagraphs(self, long1, long2):
  99.         long1 = (long1[0], 0)
  100.         long2 = (long2[0], len(self.paralist[long2[0]].extract()))
  101.         return (long1, long2)
  102.  
  103.  
  104.  
  105. class WritingBackEnd(NullBackEnd):
  106.     
  107.     def __init__(self, d, width):
  108.         self.d = d
  109.         self.width = width
  110.         self.lineno = 0
  111.  
  112.     
  113.     def addpara(self, p):
  114.         self.lineno = p.render(self.d, 0, self.lineno, self.width)
  115.  
  116.  
  117.  
  118. class BaseFormatter:
  119.     
  120.     def __init__(self, d, b):
  121.         self.d = d
  122.         self.b = b
  123.         self.leftindent = 0
  124.         self.just = 'l'
  125.         self.font = None
  126.         self.blanklines = 0
  127.         self.space = d.textwidth(' ')
  128.         self.line = d.lineheight()
  129.         self.ascent = d.baseline()
  130.         self.descent = self.line - self.ascent
  131.         self.n_space = self.space
  132.         self.para = None
  133.         self.nospace = 1
  134.         self.nextfont = None
  135.  
  136.     
  137.     def newpara(self):
  138.         return Para.Para()
  139.  
  140.     
  141.     def setfont(self, font):
  142.         if font == None:
  143.             return None
  144.         
  145.         self.font = self.nextfont = font
  146.         d = self.d
  147.         d.setfont(font)
  148.         self.space = d.textwidth(' ')
  149.         self.line = d.lineheight()
  150.         self.ascent = d.baseline()
  151.         self.descent = self.line - self.ascent
  152.  
  153.     
  154.     def setleftindent(self, nspaces):
  155.         self.leftindent = int(self.n_space * nspaces)
  156.         if self.para:
  157.             hang = self.leftindent - self.para.indent_left
  158.             if hang > 0 and self.para.getlength() <= hang:
  159.                 self.para.makehangingtag(hang)
  160.                 self.nospace = 1
  161.             else:
  162.                 self.flush()
  163.         
  164.  
  165.     
  166.     def setrightindent(self, nspaces):
  167.         self.rightindent = int(self.n_space * nspaces)
  168.         if self.para:
  169.             self.para.indent_right = self.rightindent
  170.             self.flush()
  171.         
  172.  
  173.     
  174.     def setjust(self, just):
  175.         self.just = just
  176.         if self.para:
  177.             self.para.just = self.just
  178.         
  179.  
  180.     
  181.     def flush(self):
  182.         if self.para:
  183.             self.b.addpara(self.para)
  184.             self.para = None
  185.             if self.font != None:
  186.                 self.d.setfont(self.font)
  187.             
  188.         
  189.         self.nospace = 1
  190.  
  191.     
  192.     def vspace(self, nlines):
  193.         self.flush()
  194.         if nlines > 0:
  195.             self.para = self.newpara()
  196.             tuple = (None, '', 0, 0, 0, int(nlines * self.line), 0)
  197.             self.para.words.append(tuple)
  198.             self.flush()
  199.             self.blanklines = self.blanklines + nlines
  200.         
  201.  
  202.     
  203.     def needvspace(self, nlines):
  204.         self.flush()
  205.         if nlines > self.blanklines:
  206.             self.vspace(nlines - self.blanklines)
  207.         
  208.  
  209.     
  210.     def addword(self, text, space):
  211.         if self.nospace and not text:
  212.             return None
  213.         
  214.         self.nospace = 0
  215.         self.blanklines = 0
  216.         if not (self.para):
  217.             self.para = self.newpara()
  218.             self.para.indent_left = self.leftindent
  219.             self.para.just = self.just
  220.             self.nextfont = self.font
  221.         
  222.         space = int(space * self.space)
  223.         self.para.words.append(self.nextfont, text, self.d.textwidth(text), space, space, self.ascent, self.descent)
  224.         self.nextfont = None
  225.  
  226.     
  227.     def bgn_anchor(self, id):
  228.         if not (self.para):
  229.             self.nospace = 0
  230.             self.addword('', 0)
  231.         
  232.         self.para.bgn_anchor(id)
  233.  
  234.     
  235.     def end_anchor(self, id):
  236.         if not (self.para):
  237.             self.nospace = 0
  238.             self.addword('', 0)
  239.         
  240.         self.para.end_anchor(id)
  241.  
  242.     
  243.     def hrule(self):
  244.         self.flush()
  245.         self.addword('-' * 60, 0)
  246.         self.flush()
  247.  
  248.  
  249.  
  250. class NullMeasurer:
  251.     
  252.     def __init__(self):
  253.         pass
  254.  
  255.     
  256.     def setfont(self, font):
  257.         pass
  258.  
  259.     
  260.     def textwidth(self, text):
  261.         return len(text)
  262.  
  263.     
  264.     def lineheight(self):
  265.         return 1
  266.  
  267.     
  268.     def baseline(self):
  269.         return 0
  270.  
  271.  
  272.  
  273. class FileWriter:
  274.     
  275.     def __init__(self, fp):
  276.         self.fp = fp
  277.         (self.lineno, self.colno) = (0, 0)
  278.  
  279.     
  280.     def setfont(self, font):
  281.         pass
  282.  
  283.     
  284.     def text(self, .2, str):
  285.         (h, v) = .2
  286.         if not str:
  287.             return None
  288.         
  289.         if '\n' in str:
  290.             raise ValueError, "can't write \\n"
  291.         
  292.         while self.lineno < v:
  293.             self.fp.write('\n')
  294.             (self.colno, self.lineno) = (0, self.lineno + 1)
  295.         while self.lineno > v:
  296.             self.fp.write('\x1b[A')
  297.             self.lineno = self.lineno - 1
  298.         if self.colno < h:
  299.             self.fp.write(' ' * (h - self.colno))
  300.         elif self.colno > h:
  301.             self.fp.write('\x08' * (self.colno - h))
  302.         
  303.         self.colno = h
  304.         self.fp.write(str)
  305.         self.colno = h + len(str)
  306.  
  307.  
  308.  
  309. class NullFormatter(BaseFormatter):
  310.     
  311.     def __init__(self):
  312.         d = NullMeasurer()
  313.         b = NullBackEnd()
  314.         BaseFormatter.__init__(self, d, b)
  315.  
  316.  
  317.  
  318. class WritingFormatter(BaseFormatter):
  319.     
  320.     def __init__(self, fp, width):
  321.         dm = NullMeasurer()
  322.         dw = FileWriter(fp)
  323.         b = WritingBackEnd(dw, width)
  324.         BaseFormatter.__init__(self, dm, b)
  325.         self.blanklines = 1
  326.  
  327.     
  328.     def needvspace(self, nlines):
  329.         BaseFormatter.needvspace(self, min(1, nlines))
  330.  
  331.  
  332.  
  333. class FunnyFormatter(WritingFormatter):
  334.     
  335.     def flush(self):
  336.         if self.para:
  337.             finalize(self.para)
  338.         
  339.         WritingFormatter.flush(self)
  340.  
  341.  
  342. openchar = {
  343.     'b': '*',
  344.     'i': '_',
  345.     'u': '_',
  346.     'q': '`',
  347.     'B': '*',
  348.     'I': '_',
  349.     'U': '_',
  350.     'Q': '`' }
  351. closechar = {
  352.     'b': '*',
  353.     'i': '_',
  354.     'u': '_',
  355.     'q': "'",
  356.     'B': '*',
  357.     'I': '_',
  358.     'U': '_',
  359.     'Q': "'" }
  360.  
  361. def finalize(para):
  362.     oldfont = curfont = 'r'
  363.     para.words.append('r', '', 0, 0, 0, 0)
  364.     for i in range(len(para.words)):
  365.         (fo, te, wi) = para.words[i][:3]
  366.         if curfont != oldfont:
  367.             if openchar.has_key(curfont) and te:
  368.                 c = openchar[curfont]
  369.                 te = c + te
  370.                 wi = len(c) + wi
  371.                 para.words[i] = (fo, te, wi) + para.words[i][3:]
  372.             
  373.             if te:
  374.                 oldfont = curfont
  375.             else:
  376.                 oldfont = 'r'
  377.         
  378.         if curfont in string.uppercase:
  379.             te = string.upper(te)
  380.             para.words[i] = (fo, te, wi) + para.words[i][3:]
  381.         
  382.     
  383.     del para.words[-1]
  384.  
  385.  
  386. class StdwinBackEnd(SavingBackEnd):
  387.     
  388.     def __init__(self, window, drawnow):
  389.         self.window = window
  390.         self.drawnow = drawnow
  391.         self.width = window.getwinsize()[0]
  392.         self.selection = None
  393.         self.height = 0
  394.         window.setorigin(0, 0)
  395.         window.setdocsize(0, 0)
  396.         self.d = window.begindrawing()
  397.         SavingBackEnd.__init__(self)
  398.  
  399.     
  400.     def finish(self):
  401.         self.d.close()
  402.         self.d = None
  403.         self.window.setdocsize(0, self.height)
  404.  
  405.     
  406.     def addpara(self, p):
  407.         self.paralist.append(p)
  408.         if self.drawnow:
  409.             self.height = p.render(self.d, 0, self.height, self.width)
  410.         else:
  411.             p.layout(self.width)
  412.             p.left = 0
  413.             p.top = self.height
  414.             p.right = self.width
  415.             p.bottom = self.height + p.height
  416.             self.height = p.bottom
  417.  
  418.     
  419.     def resize(self):
  420.         self.window.change((0, 0), (self.width, self.height))
  421.         self.width = self.window.getwinsize()[0]
  422.         self.height = 0
  423.         for p in self.paralist:
  424.             p.layout(self.width)
  425.             p.left = 0
  426.             p.top = self.height
  427.             p.right = self.width
  428.             p.bottom = self.height + p.height
  429.             self.height = p.bottom
  430.         
  431.         self.window.change((0, 0), (self.width, self.height))
  432.         self.window.setdocsize(0, self.height)
  433.  
  434.     
  435.     def redraw(self, area):
  436.         d = self.window.begindrawing()
  437.         (left, top) = ()
  438.         (right, bottom) = area
  439.         d.erase(area)
  440.         d.cliprect(area)
  441.         for p in self.paralist:
  442.             pass
  443.         
  444.         if self.selection:
  445.             self.invert(d, self.selection)
  446.         
  447.         d.close()
  448.  
  449.     
  450.     def setselection(self, new):
  451.         if new:
  452.             (long1, long2) = new
  453.             pos1 = long1[:3]
  454.             pos2 = long2[:3]
  455.             new = (pos1, pos2)
  456.         
  457.         if new != self.selection:
  458.             d = self.window.begindrawing()
  459.             if self.selection:
  460.                 self.invert(d, self.selection)
  461.             
  462.             if new:
  463.                 self.invert(d, new)
  464.             
  465.             d.close()
  466.             self.selection = new
  467.         
  468.  
  469.     
  470.     def getselection(self):
  471.         return self.selection
  472.  
  473.     
  474.     def extractselection(self):
  475.         if self.selection:
  476.             (a, b) = self.selection
  477.             return self.extractpart(a, b)
  478.         else:
  479.             return None
  480.  
  481.     
  482.     def invert(self, d, region):
  483.         (long1, long2) = region
  484.         if long1 > long2:
  485.             (long1, long2) = (long2, long1)
  486.         
  487.         (para1, pos1) = long1
  488.         (para2, pos2) = long2
  489.         while para1 < para2:
  490.             self.paralist[para1].invert(d, pos1, None)
  491.             pos1 = None
  492.             para1 = para1 + 1
  493.         self.paralist[para2].invert(d, pos1, pos2)
  494.  
  495.     
  496.     def search(self, prog):
  497.         import regex
  498.         import string
  499.         if type(prog) == type(''):
  500.             prog = regex.compile(string.lower(prog))
  501.         
  502.         if self.selection:
  503.             iold = self.selection[0][0]
  504.         else:
  505.             iold = -1
  506.         hit = None
  507.         for i in range(len(self.paralist)):
  508.             p = self.paralist[i]
  509.             text = string.lower(p.extract())
  510.             if prog.search(text) >= 0:
  511.                 (a, b) = prog.regs[0]
  512.                 long1 = (i, a)
  513.                 long2 = (i, b)
  514.                 hit = (long1, long2)
  515.                 if i > iold:
  516.                     break
  517.                 
  518.             
  519.         
  520.         if hit:
  521.             self.setselection(hit)
  522.             i = hit[0][0]
  523.             p = self.paralist[i]
  524.             self.window.show((p.left, p.top), (p.right, p.bottom))
  525.             return 1
  526.         else:
  527.             return 0
  528.  
  529.     
  530.     def showanchor(self, id):
  531.         for i in range(len(self.paralist)):
  532.             p = self.paralist[i]
  533.         
  534.  
  535.  
  536.  
  537. class GLFontCache:
  538.     
  539.     def __init__(self):
  540.         self.reset()
  541.         self.setfont('')
  542.  
  543.     
  544.     def reset(self):
  545.         self.fontkey = None
  546.         self.fonthandle = None
  547.         self.fontinfo = None
  548.         self.fontcache = { }
  549.  
  550.     
  551.     def close(self):
  552.         self.reset()
  553.  
  554.     
  555.     def setfont(self, fontkey):
  556.         if fontkey == '':
  557.             fontkey = 'Times-Roman 12'
  558.         elif ' ' not in fontkey:
  559.             fontkey = fontkey + ' 12'
  560.         
  561.         if fontkey == self.fontkey:
  562.             return None
  563.         
  564.         if self.fontcache.has_key(fontkey):
  565.             handle = self.fontcache[fontkey]
  566.         else:
  567.             import string
  568.             i = string.index(fontkey, ' ')
  569.             (name, sizestr) = (fontkey[:i], fontkey[i:])
  570.             size = eval(sizestr)
  571.             key1 = name + ' 1'
  572.             key = name + ' ' + `size`
  573.             if self.fontcache.has_key(key):
  574.                 handle = self.fontcache[key]
  575.             elif self.fontcache.has_key(key1):
  576.                 handle = self.fontcache[key1]
  577.             else:
  578.                 import fm
  579.                 handle = fm.findfont(name)
  580.                 self.fontcache[key1] = handle
  581.             handle = handle.scalefont(size)
  582.             self.fontcache[fontkey] = self.fontcache[key] = handle
  583.         self.fontkey = fontkey
  584.         if self.fonthandle != handle:
  585.             self.fonthandle = handle
  586.             self.fontinfo = handle.getfontinfo()
  587.             handle.setfont()
  588.         
  589.  
  590.  
  591.  
  592. class GLMeasurer(GLFontCache):
  593.     
  594.     def textwidth(self, text):
  595.         return self.fonthandle.getstrwidth(text)
  596.  
  597.     
  598.     def baseline(self):
  599.         return self.fontinfo[6] - self.fontinfo[3]
  600.  
  601.     
  602.     def lineheight(self):
  603.         return self.fontinfo[6]
  604.  
  605.  
  606.  
  607. class GLWriter(GLFontCache):
  608.     
  609.     def text(self, .2, text):
  610.         (h, v) = .2
  611.         import gl
  612.         import fm
  613.         gl.cmov2i(h, v + self.fontinfo[6] - self.fontinfo[3])
  614.         fm.prstr(text)
  615.  
  616.     
  617.     def setfont(self, fontkey):
  618.         oldhandle = self.fonthandle
  619.         GLFontCache.setfont(fontkey)
  620.         if self.fonthandle != oldhandle:
  621.             handle.setfont()
  622.         
  623.  
  624.  
  625.  
  626. class GLMeasurerWriter(GLMeasurer, GLWriter):
  627.     pass
  628.  
  629.  
  630. class GLBackEnd(SavingBackEnd):
  631.     
  632.     def __init__(self, wid):
  633.         import gl
  634.         gl.winset(wid)
  635.         self.wid = wid
  636.         self.width = gl.getsize()[1]
  637.         self.height = 0
  638.         self.d = GLMeasurerWriter()
  639.         SavingBackEnd.__init__(self)
  640.  
  641.     
  642.     def finish(self):
  643.         pass
  644.  
  645.     
  646.     def addpara(self, p):
  647.         self.paralist.append(p)
  648.         self.height = p.render(self.d, 0, self.height, self.width)
  649.  
  650.     
  651.     def redraw(self):
  652.         import gl
  653.         gl.winset(self.wid)
  654.         width = gl.getsize()[1]
  655.         d = self.d
  656.         v = 0
  657.         for p in self.paralist:
  658.             v = p.render(d, 0, v, width)
  659.         
  660.  
  661.  
  662.